声明 模块 "http" {

    //@@{ 事件组:events }
    导入 * 转为 事件组 来自 "events";

    //@@{ 流:stream }
    导入 * 转为 流 来自 "stream";
    导入 { URL } 来自 "url";

    //@@{ 套接字_:Socket, 服务器_:Server, 网络服务器_:NetServer }
    导入 { 套接字_, 服务器_ 转为 网络服务器_ } 来自 "net";

    // incoming headers will never contain number

    //@@{ 传入的Http头_:IncomingHttpHeaders }
    接口 传入的Http头_ {

        //@@{ "接受":"accept" }
        "接受"?: 文字;

        //@@{ "接受-语言":"accept-language" }
        "接受-语言"?: 文字;

        //@@{ "接受-路径":"accept-patch" }
        "接受-路径"?: 文字;

        //@@{ "接受-范围":"accept-ranges" }
        "接受-范围"?: 文字;

        //@@{ "访问-控制-允许-凭据":"access-control-allow-credentials" }
        "访问-控制-允许-凭据"?: 文字;

        //@@{ "访问-控制-允许-报头":"access-control-allow-headers" }
        "访问-控制-允许-报头"?: 文字;

        //@@{ "访问-控制-允许-方法":"access-control-allow-methods" }
        "访问-控制-允许-方法"?: 文字;

        //@@{ "访问-控制-允许-原点":"access-control-allow-origin" }
        "访问-控制-允许-原点"?: 文字;

        //@@{ "访问-控制-公开-报头":"access-control-expose-headers" }
        "访问-控制-公开-报头"?: 文字;

        //@@{ "访问-控制-最大-年龄":"access-control-max-age" }
        "访问-控制-最大-年龄"?: 文字;

        //@@{ "年龄":"age" }
        "年龄"?: 文字;

        //@@{ "允许":"allow" }
        "允许"?: 文字;

        //@@{ "替代-服务":"alt-svc" }
        "替代-服务"?: 文字;

        //@@{ "授权":"authorization" }
        "授权"?: 文字;

        //@@{ "缓存-控制":"cache-control" }
        "缓存-控制"?: 文字;

        //@@{ "连接":"connection" }
        "连接"?: 文字;

        //@@{ "内容-配置":"content-disposition"}
        "内容-配置"?: 文字;

        //@@{ "内容-编码":"content-encoding" }
        "内容-编码"?: 文字;

        //@@{ "内容-语言":"content-language" }
        "内容-语言"?: 文字;

        //@@{ "内容-长度":"content-length" }
        "内容-长度"?: 文字;

        //@@{ "内容-位置":"content-location" }
        "内容-位置"?: 文字;

        //@@{ "内容-范围":"content-range" }
        "内容-范围"?: 文字;
        
        //@@{ "内容-类型":"content-type" }
        "内容-类型"?: 文字;

        //@@{ "浏览器缓存":"cookie" }
        "浏览器缓存"?: 文字;

        //@@{ "日期":"date" }
        "日期"?: 文字;

        //@@{ "期待":"expect" }
        "期待"?: 文字;

        //@@{ "到期":"expires" }
        "到期"?: 文字;

        //@@{ "转发的":"forwarded" }
        "转发的"?: 文字;

        //@@{ "来自":"from" }
        "来自"?: 文字;

        //@@{ "主机":"host" }
        "主机"?: 文字;

        //@@{ "如果-匹配":"if-match" }
        "如果-匹配"?: 文字;

        //@@{ "如果-修饰-后":"if-modified-since" }
        "如果-修饰-后"?: 文字;

        //@@{ "如果-没有-匹配":"if-none-match" }
        "如果-没有-匹配"?: 文字;

        //@@{ "如果-没有修饰-后":"if-unmodified-since" }
        "如果-没有修饰-后"?: 文字;

        //@@{ "最后的-修饰符":"last-modified"}
        "最后的-修饰符"?: 文字;

        //@@{ "位置":"location" }
        "位置"?: 文字;

        //@@{ "杂注":"pragma" }
        "杂注"?: 文字;

        //@@{ "代理-身份验证":"proxy-authenticate" }
        "代理-身份验证"?: 文字;

        //@@{ "代理-授权":"proxy-authorization" }
        "代理-授权"?: 文字;

        //@@{ "公钥-信息":"public-key-pins" }
        "公钥-信息"?: 文字;

        //@@{ "范围":"range" }
        "范围"?: 文字;

        //@@{ "引用者":"referer" }
        "引用者"?: 文字;

        //@@{ "重试-后":"retry-after" }
        "重试-后"?: 文字;

        //@@{ "设置-cookie":"set-cookie"}
        "设置-cookie"?: 文字[];

        //@@{ "严格-传输-安全":"strict-transport-security"}
        "严格-传输-安全"?: 文字;

        "tk"?: 文字;

        //@@{ "预告片":"trailer" }
        "预告片"?: 文字;

        //@@{ "转换-编码":"transfer-encoding" }
        "转换-编码"?: 文字;

        //@@{ "向上等级":"upgrade" }
        "向上等级"?: 文字;

        //@@{ "用户-代理":"user-agent" }
        "用户-代理"?: 文字;

        //@@{ "差别":"vary" }
        "差别"?: 文字;

        //@@{ "版本协议":"via" }
        "版本协议"?: 文字;

        //@@{ "警告":"warning" }
        "警告"?: 文字;

        //@@{ "www-认证":"www-authenticate" }
        "www-认证"?: 文字;
        [头部: 文字]: 文字 | 文字[] | 未定;
    }

    // outgoing headers allows numbers (as they are converted internally to strings)

    //@@{ 即将离开的Http头_:OutgoingHttpHeaders }
    接口 即将离开的Http头_ {
        [头部: 文字]: 数字 | 文字 | 文字[] | 未定;
    }

    //@@{ 客户端请求参数_:ClientRequestArgs }
    接口 客户端请求参数_ {

        //@@{ 协议:protocol }
        协议?: 文字;

        //@@{ 主机:host }
        主机?: 文字;

        //@@{ 主机名:hostname }
        主机名?: 文字;

        //@@{ 家族:family }
        家族?: 数字;

        //@@{ 端口:port }
        端口?: 数字 | 文字;

        //@@{ 默认端口:defaultPort }
        默认端口?: 数字 | 文字;

        //@@{ 本地地址:localAddress }
        本地地址?: 文字;

        //@@{ 套接字路径:socketPath }
        套接字路径?: 文字;

        //@@{ 方法:method }
        方法?: 文字;

        //@@{ 路径:path }
        路径?: 文字;

        //@@{ 报头:headers, 即将离开的Http头_:OutgoingHttpHeaders }
        报头?: 即将离开的Http头_;

        //@@{ 身份验证:auth }
        身份验证?: 文字;

        //@@{ 代理:agent, 代理_:Agent }
        代理?: 代理_ | 真假;

        //@@{ _默认代理:_defaultAgent, 代理_:Agent }
        _默认代理?: 代理_;

        //@@{ 超时:timeout }
        超时?: 数字;

        //@@{ 设置主机:setHost }
        设置主机?: 真假;
        // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L278

        //@@{ 创建连接:createConnection, 客户端请求参数_:ClientRequestArgs, 错误_:Error, 套接字_:Socket }
        创建连接?: (选项组: 客户端请求参数_, 正在创建: (错: 错误_, 套接字: 套接字_) => 无值) => 套接字_;
    }

    //@@{ 服务器选项_:ServerOptions }
    接口 服务器选项_ {

        //@@{ 传入消息_:IncomingMessage }
        传入消息_?: 类为 传入消息_;

        //@@{ 服务器响应_:ServerResponse }
        服务器响应_?: 类为 服务器响应_;
    }

    //@@{ 请求监听器_:RequestListener, 传入消息_:IncomingMessage, 服务器响应_:ServerResponse }
    类型 请求监听器_ = (请求: 传入消息_, 响应: 服务器响应_) => 无值;

    //@@{ 服务器_:Server, 网络服务器_:NetServer }
    类别 服务器_ 扩展 网络服务器_ {

        //@@{ 请求监听器_:RequestListener }
        构造(请求监听器?: 请求监听器_);

        //@@{ 服务器选项_:ServerOptions, 请求监听器_:RequestListener }
        构造(选项组: 服务器选项_, 请求监听器?: 请求监听器_);

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开?: 数字, 回调?: () => 无值): 本体;

        //@@{ 设置超时:setTimeout }
        设置超时(回调: () => 无值): 本体;
        /**
         * Limits maximum incoming headers count. If set to 0, no limit will be applied.
         * @default 2000
         * {@link https://nodejs.org/api/http.html#http_server_maxheaderscount}
         */

        //@@{ 最大头数量:maxHeadersCount }
        最大头数量: 数字 | 空值;

        //@@{ 超时:timeout }
        超时: 数字;
        /**
         * Limit the amount of time the parser will wait to receive the complete HTTP headers.
         * @default 40000
         * {@link https://nodejs.org/api/http.html#http_server_headerstimeout}
         */

        //@@{ 报头超时:headersTimeout }
        报头超时: 数字;

        //@@{ 保持超时:keepAliveTimeout }
        保持超时: 数字;
    }

    // https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js

    //@@{ 即将离开的消息_:OutgoingMessage, 流:stream, 可写的_:Writable }
    类别 即将离开的消息_ 扩展 流.可写的_ {

        //@@{ 升级:upgrading }
        升级: 真假;

        //@@{ 分块编码:chunkedEncoding }
        分块编码: 真假;

        //@@{ 应该保持存活:shouldKeepAlive }
        应该保持存活: 真假;

        //@@{ 默认使用分块编码:useChunkedEncodingByDefault }
        默认使用分块编码: 真假;

        //@@{ 发送日期:sendDate }
        发送日期: 真假;

        //@@{ 完成了:finished }
        完成了: 真假;

        //@@{ 头发送:headersSent }
        头发送: 真假;

        //@@{ 连接:connection, 套接字_:Socket }
        连接: 套接字_;

        构造();

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调?: () => 无值): 本体;

        //@@{ 设置头:setHeader }
        设置头(名称: 文字, 值: 数字 | 文字 | 文字[]): 无值;

        //@@{ 获取头:getHeader }
        获取头(名称: 文字): 数字 | 文字 | 文字[] | 未定;

        //@@{ 获取头集:getHeaders, 即将离开的Http头_:OutgoingHttpHeaders }
        获取头集(): 即将离开的Http头_;

        //@@{ 获取头名字:getHeaderNames }
        获取头名字(): 文字[];

        //@@{ 具有头:hasHeader }
        具有头(名称: 文字): 真假;

        //@@{ 删除头:removeHeader }
        删除头(名称: 文字): 无值;

        //@@{ 添加预告:addTrailers, 即将离开的Http头_:OutgoingHttpHeaders, 数组_:Array }
        添加预告(报头: 即将离开的Http头_ | 数组_<[文字, 文字]>): 无值;

        //@@{ 刷新请求头:flushHeaders }
        刷新请求头(): 无值;
    }

    // https://github.com/nodejs/node/blob/master/lib/_http_server.js#L108-L256

    //@@{ 服务器响应_:ServerResponse, 即将离开的消息_:OutgoingMessage }
    类别 服务器响应_ 扩展 即将离开的消息_ {

        //@@{ 状态代码:statusCode }
        状态代码: 数字;

        //@@{ 状态消息:statusMessage }
        状态消息: 文字;

        //@@{ 传入消息_:IncomingMessage }
        构造(请求: 传入消息_);

        //@@{ 指定套接字:assignSocket, 套接字_:Socket }
        指定套接字(套接字: 套接字_): 无值;

        //@@{ 分离套接字:detachSocket, 套接字_:Socket }
        分离套接字(套接字: 套接字_): 无值;
        // https://github.com/nodejs/node/blob/master/test/parallel/test-http-write-callbacks.js#L53
        // no args in writeContinue callback

        //@@{ 写继续:writeContinue }
        写继续(回调?: () => 无值): 无值;

        //@@{ 写头:writeHead, 即将离开的Http头_:OutgoingHttpHeaders }
        写头(状态代码: 数字, 原因短语?: 文字, 报头?: 即将离开的Http头_): 本体;

        //@@{ 写头:writeHead, 即将离开的Http头_:OutgoingHttpHeaders }
        写头(状态代码: 数字, 报头?: 即将离开的Http头_): 本体;
    }

    // https://github.com/nodejs/node/blob/master/lib/_http_client.js#L77

    //@@{ 客户端请求_:ClientRequest, 即将离开的消息_:OutgoingMessage }
    类别 客户端请求_ 扩展 即将离开的消息_ {

        //@@{ 连接:connection, 套接字_:Socket }
        连接: 套接字_;

        //@@{ 套接字:socket, 套接字_:Socket }
        套接字: 套接字_;

        //@@{ 中止的:aborted }
        中止的: 数字;

        //@@{ 客户端请求参数_:ClientRequestArgs, 传入消息_:IncomingMessage }
        构造(url: 文字 | URL | 客户端请求参数_, 回调?: (响应: 传入消息_) => 无值);

        //@@{ 路径:path }
        只读 路径: 文字;

        //@@{ 中止:abort }
        中止(): 无值;

        //@@{ 正在套接字:onSocket, 套接字_:Socket }
        正在套接字(套接字: 套接字_): 无值;

        //@@{ 设置超时:setTimeout }
        设置超时(超时: 数字, 回调?: () => 无值): 本体;

        //@@{ 设置没有延迟:setNoDelay }
        设置没有延迟(没有延迟?: 真假): 无值;

        //@@{ 设置套接字保持存活:setSocketKeepAlive }
        设置套接字保持存活(启用?: 真假, 初始延迟?: 数字): 无值;
    }

    //@@{ 传入消息_:IncomingMessage, 流:stream, 可读的_:Readable }
    类别 传入消息_ 扩展 流.可读的_ {

        //@@{ 套接字_:Socket }
        构造(套接字: 套接字_);

        //@@{ http版本:httpVersion }
        http版本: 文字;

        //@@{ http版本主:httpVersionMajor }
        http版本主: 数字;

        //@@{ http版本次:httpVersionMinor }
        http版本次: 数字;

        //@@{ 完成了:complete }
        完成了: 真假;

        //@@{ 连接:connection, 套接字_:Socket }
        连接: 套接字_;

        //@@{ 报头:headers, 传入的Http头_:IncomingHttpHeaders }
        报头: 传入的Http头_;

        //@@{ 原始头组:rawHeaders }
        原始头组: 文字[];

        //@@{ 预告:trailers }
        预告: { [键: 文字]: 文字 | 未定 };

        //@@{ 原始预告组:rawTrailers }
        原始预告组: 文字[];

        //@@{ 设置超时:setTimeout }
        设置超时(毫秒断开: 数字, 回调: () => 无值): 本体;
        /**
         * Only valid for request obtained from http.Server.
         */

        //@@{ 方法:method }
        方法?: 文字;
        /**
         * Only valid for request obtained from http.Server.
         */
        url?: 文字;
        /**
         * Only valid for response obtained from http.ClientRequest.
         */

        //@@{ 状态代码:statusCode }
        状态代码?: 数字;
        /**
         * Only valid for response obtained from http.ClientRequest.
         */

        //@@{ 状态消息:statusMessage }
        状态消息?: 文字;

        //@@{ 套接字:socket, 套接字_:Socket }
        套接字: 套接字_;

        //@@{ 销毁:destroy, 错误_:Error }
        销毁(错误?: 错误_): 无值;
    }

    //@@{ 代理选项_:AgentOptions }
    接口 代理选项_ {
        /**
         * Keep sockets around in a pool to be used by other requests in the future. Default = false
         */

        //@@{ 保持存活:keepAlive }
        保持存活?: 真假;
        /**
         * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
         * Only relevant if keepAlive is set to true.
         */

        //@@{ 保持存活毫秒:keepAliveMsecs }
        保持存活毫秒?: 数字;
        /**
         * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
         */

        //@@{ 最大套接字:maxSockets }
        最大套接字?: 数字;
        /**
         * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
         */

        //@@{ 最大免费的套接字:maxFreeSockets }
        最大免费的套接字?: 数字;
        /**
         * Socket timeout in milliseconds. This will set the timeout after the socket is connected.
         */

        //@@{ 超时:timeout }
        超时?: 数字;
    }

    //@@{ 代理_:Agent }
    类别 代理_ {

        //@@{ 最大免费的套接字:maxFreeSockets }
        最大免费的套接字: 数字;

        //@@{ 最大套接字:maxSockets }
        最大套接字: 数字;

        //@@{ 套接字组:sockets }
        只读 套接字组: {

            //@@{ 套接字_:Socket }
            只读 [键: 文字]: 套接字_[];
        };

        //@@{ 请求组:requests }
        只读 请求组: {

            //@@{ 传入消息_:IncomingMessage }
            只读 [键: 文字]: 传入消息_[];
        };

        //@@{ 代理选项_:AgentOptions }
        构造(选项?: 代理选项_);

        /**
         * Destroy any sockets that are currently in use by the agent.
         * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled,
         * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise,
         * sockets may hang open for quite a long time before the server terminates them.
         */

        //@@{ 销毁:destroy }
        销毁(): 无值;
    }

    //@@{ __方法__:METHODS }
    常量 __方法__: 文字[];

    //@@{ __状态_代码__:STATUS_CODES }
    常量 __状态_代码__: {
        [错误代码: 数字]: 文字 | 未定;
        [错误代码: 文字]: 文字 | 未定;
    };

    //@@{ 创建服务器:createServer, 请求监听器_:RequestListener, 服务器_:Server }
    函数 创建服务器(请求监听器?: 请求监听器_): 服务器_;

    //@@{ 创建服务器:createServer, 服务器选项_:ServerOptions, 请求监听器_:RequestListener }
    //@@{ 服务器_:Server }
    函数 创建服务器(选项组: 服务器选项_, 请求监听器?: 请求监听器_): 服务器_;

    // although RequestOptions are passed as ClientRequestArgs to ClientRequest directly,
    // create interface RequestOptions would make the naming more clear to developers

    //@@{ 请求选项_:RequestOptions, 客户端请求参数_:ClientRequestArgs }
    接口 请求选项_ 扩展 客户端请求参数_ { }

    //@@{ 请求:request, 请求选项_:RequestOptions, 传入消息_:IncomingMessage, 客户端请求_:ClientRequest }
    函数 请求(选项组: 请求选项_ | 文字 | URL, 回调?: (响应: 传入消息_) => 无值): 客户端请求_;

    //@@{ 请求:request, 请求选项_:RequestOptions, 传入消息_:IncomingMessage, 客户端请求_:ClientRequest }
    函数 请求(url: 文字 | URL, 选项组: 请求选项_, 回调?: (响应: 传入消息_) => 无值): 客户端请求_;

    //@@{ 获取:get, 请求选项_:RequestOptions, 传入消息_:IncomingMessage, 客户端请求_:ClientRequest }
    函数 获取(选项组: 请求选项_ | 文字 | URL, 回调?: (响应: 传入消息_) => 无值): 客户端请求_;

    //@@{ 获取:get, 请求选项_:RequestOptions, 传入消息_:IncomingMessage, 客户端请求_:ClientRequest }
    函数 获取(url: 文字 | URL, 选项组: 请求选项_, 回调?: (响应: 传入消息_) => 无值): 客户端请求_;

    //@@{ 全局代理:globalAgent, 代理_:Agent }
    变量 全局代理: 代理_;

    /**
     * Read-only property specifying the maximum allowed size of HTTP headers in bytes.
     * Defaults to 8KB. Configurable using the [`--max-http-header-size`][] CLI option.
     */

    //@@{ 最大头大小:maxHeaderSize }
    常量 最大头大小: 数字;
}
